home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 May: Tool Chest / Developer CD Series May 1996 (Tool Chest) (Apple Computer) (1996).iso / Sample Code / Snippets / Devices / Audio CD ƒ / cd.c next >
Encoding:
Text File  |  1992-07-15  |  7.9 KB  |  296 lines  |  [TEXT/MPS ]
  1. // imWare
  2. // Wednesday, February 14, 1990
  3. // James Beninghaus
  4.  
  5. #include    <ToolUtils.h>
  6. #include    <Memory.h>
  7. #include    <Errors.h>
  8. #include    <cd.h>
  9.  
  10. pascal    Byte Decimal2BCD(Byte n) {
  11.     return ((n / 10) << 4) + (n % 10); 
  12. }
  13.  
  14. pascal    Byte BCD2Decimal(Byte n) {
  15.     return ((n >> 4) * 10) + (n & 0x0f);
  16. }
  17.  
  18. pascal    OSErr OpenCD(Byte CDDrive, short *ioRefNum) {
  19.  
  20.     auto    OSErr            osErr;
  21.     auto    short            ioRefNumTemp,
  22.                             CDDriveCount,
  23.                             SCSIID;
  24.     auto    WhoIsThereRec    *pb;
  25.  
  26.     pb = (WhoIsThereRec *) NewPtrClear(sizeof (*pb));
  27.     osErr = MemError();
  28.     if (0 != pb && noErr == osErr) {
  29.         osErr = OpenDriver("\p.AppleCD", &ioRefNumTemp);
  30.         if (noErr == osErr) {
  31.             (*pb).ioRefNum        = ioRefNumTemp;
  32.             (*pb).csCode        = csWhoIsThere;
  33.             osErr = PBStatus((ParmBlkPtr)pb, false);
  34.             if (noErr == osErr) {
  35.                 CDDriveCount = 0;
  36.                 for (SCSIID = 0; SCSIID < 7; ++SCSIID) {
  37.                     if (BitTst(&(*pb).csParam.SCSIMask, 7 - SCSIID)) {
  38.                         ++CDDriveCount;
  39.                         if (CDDrive == CDDriveCount) {
  40.                             *ioRefNum = -(32 + SCSIID) - 1;
  41.                             DisposPtr((Ptr) pb);
  42.                             return noErr;
  43.                         }
  44.                     }
  45.                 }
  46.                 osErr = paramErr;
  47.             }
  48.         }
  49.         DisposPtr((Ptr) pb);
  50.     }
  51.     return osErr;
  52. }
  53.  
  54. pascal    OSErr EjectCD(short ioRefNum) {
  55.  
  56.     auto    OSErr            osErr;
  57.     auto    Str255            ioName;
  58.     auto    HVolumeParam    *pb;
  59.     
  60.     pb = (HVolumeParam *) NewPtrClear(sizeof (*pb));
  61.     osErr = MemError();
  62.     if (0 != pb && noErr == osErr) {
  63.         (*pb).ioNamePtr    = ioName;
  64.         (*pb).ioVolIndex = 0;
  65.         do {
  66.             ++(*pb).ioVolIndex;
  67.             osErr = PBHGetVInfo((HParmBlkPtr)pb, false);
  68.             if (noErr != osErr) {
  69.                 DisposPtr((Ptr) pb);
  70.                 return osErr;
  71.             }
  72.         } while ((*pb).ioVDRefNum != ioRefNum);
  73.         osErr = PBEject((ParmBlkPtr)pb);
  74.         if (noErr == osErr)
  75.              osErr = PBUnmountVol((ParmBlkPtr)pb);
  76.         DisposPtr((Ptr) pb);
  77.     }
  78.     return osErr;
  79. }
  80.  
  81. pascal    OSErr APlay(short ioRefNum, Byte startTrack, Byte playMode) {
  82.  
  83.     auto    OSErr            osErr;
  84.     auto    APlayRec        *pb;    
  85.  
  86.     pb = (APlayRec *) NewPtrClear(sizeof (*pb));
  87.     osErr = MemError();
  88.     if (0 != pb && noErr == osErr) {
  89.         (*pb).ioRefNum             = ioRefNum;
  90.         (*pb).csCode            = csAPlay;
  91.         (*pb).csParam.type        = TRACKADDR;
  92.         (*pb).csParam.addr[3]    = Decimal2BCD(startTrack);
  93.         (*pb).csParam.startStop    = START;
  94.         (*pb).csParam.playMode    = playMode;
  95.         osErr = PBControl((ParmBlkPtr)pb, false);
  96.         DisposPtr((Ptr) pb);
  97.     }
  98.     return osErr;
  99. }
  100.  
  101. pascal    OSErr AStop(short ioRefNum, Byte stopTrack) {
  102.  
  103.     auto    OSErr            osErr;
  104.     auto    AStopRec        *pb;    
  105.  
  106.     pb = (AStopRec *) NewPtrClear(sizeof (*pb));
  107.     osErr = MemError();
  108.     if (0 != pb && noErr == osErr) {
  109.         (*pb).ioRefNum             = ioRefNum;
  110.         (*pb).csCode            = csAStop;
  111.         (*pb).csParam.type        = 0 == stopTrack ? BLOCKADDR : TRACKADDR; 
  112.         (*pb).csParam.addr[3]    = Decimal2BCD(stopTrack);
  113.         osErr = PBControl((ParmBlkPtr)pb, false);
  114.         DisposPtr((Ptr) pb);
  115.     }
  116.     return osErr;
  117. }
  118.  
  119. pascal    OSErr APause(short ioRefNum, Long state) { 
  120.  
  121.     auto    OSErr            osErr;
  122.     auto    APauseRec        *pb;
  123.  
  124.     pb = (APauseRec *) NewPtrClear(sizeof (*pb));
  125.     osErr = MemError();
  126.     if (0 != pb && noErr == osErr) {
  127.         (*pb).ioRefNum            = ioRefNum;
  128.         (*pb).csCode            = csAPause;
  129.         (*pb).csParam.state        = state;
  130.         osErr = PBControl((ParmBlkPtr)pb, false);
  131.         DisposPtr((Ptr) pb);
  132.     }
  133.     return osErr;
  134. }
  135.  
  136. pascal    OSErr TrackCount(short ioRefNum, Byte *stopTrack) {
  137.  
  138.     auto    OSErr            osErr;
  139.     auto    ReadTOCRec        *pb;
  140.  
  141.     pb = (ReadTOCRec *) NewPtrClear(sizeof (*pb));
  142.     osErr = MemError();
  143.     if (0 != pb && noErr == osErr) {
  144.         (*pb).ioRefNum            = ioRefNum;
  145.         (*pb).csCode            = csReadTOC;
  146.         (*pb).csParam.type        = 1;
  147.         osErr = PBControl((ParmBlkPtr)pb, false);
  148.         if (noErr == osErr) {
  149.             *stopTrack            = BCD2Decimal((*pb).csParam.addr[1]);
  150.         }
  151.         DisposPtr((Ptr) pb);
  152.     }
  153.     return osErr;
  154. }
  155.  
  156. pascal    OSErr TrackInfo(short ioRefNum, Byte track, Byte *cntlField, Byte *minutes, Byte *seconds, Byte *frames) {
  157.  
  158.     auto    OSErr            osErr;
  159.     auto    ReadTOCRec        *pb;
  160.     
  161.     pb = (ReadTOCRec *) NewPtrClear(sizeof (*pb));
  162.     osErr = MemError();
  163.     if (0 != pb && noErr == osErr) {
  164.         (*pb).ioRefNum                    = ioRefNum;
  165.         (*pb).csCode                    = csReadTOC;
  166.         (*pb).csParam.type                = 3;
  167.         (*pb).csParam.buffer.data        = (Long) NewPtrClear(sizeof (StartAddrRec));
  168.         osErr = MemError();
  169.         if (0 != (*pb).csParam.buffer.data && noErr == osErr) {
  170.             (*pb).csParam.buffer.length        = sizeof(StartAddrRec);
  171.             (*pb).csParam.buffer.track        = Decimal2BCD(track);
  172.             osErr = PBControl((ParmBlkPtr)pb, false);
  173.             if (noErr == osErr) {
  174.                 *cntlField         = (*(StartAddrRec *)(*pb).csParam.buffer.data).cntlField;
  175.                 *minutes         = BCD2Decimal((*(StartAddrRec *)(*pb).csParam.buffer.data).minutes);
  176.                 *seconds        = BCD2Decimal((*(StartAddrRec *)(*pb).csParam.buffer.data).seconds);
  177.                 *frames            = BCD2Decimal((*(StartAddrRec *)(*pb).csParam.buffer.data).frames);
  178.             }
  179.             DisposPtr((Ptr) (*pb).csParam.buffer.data);
  180.         }
  181.         DisposPtr((Ptr) pb);
  182.     }
  183.     return osErr;
  184. }
  185.  
  186. pascal    OSErr ATrkSearch(short ioRefNum, Byte track, Byte playFlag, Byte playMode) {
  187.  
  188.     auto    OSErr            osErr;
  189.     auto    ATrkSearchRec    *pb;    
  190.  
  191.     pb = (ATrkSearchRec *) NewPtrClear(sizeof (*pb));
  192.     osErr = MemError();
  193.     if (0 != pb && noErr == osErr) {
  194.         (*pb).ioRefNum             = ioRefNum;
  195.         (*pb).csCode            = csATrkSearch;
  196.         (*pb).csParam.type        = TRACKADDR;
  197.         (*pb).csParam.addr[3]    = Decimal2BCD(track);
  198.         (*pb).csParam.playFlag    = playFlag;
  199.         (*pb).csParam.playMode    = playMode;
  200.         osErr = PBControl((ParmBlkPtr)pb, false);
  201.         DisposPtr((Ptr) pb);
  202.     }
  203.     return osErr;
  204. }
  205.  
  206. pascal    OSErr AStatus(short ioRefNum, Byte *audioStatus, Byte *playMode, Byte *cntlField, Byte *minutes, Byte *seconds, Byte *frames) {
  207.  
  208.     auto    OSErr            osErr;
  209.     auto    AStatusRec        *pb;
  210.  
  211.     pb = (AStatusRec *) NewPtrClear(sizeof (*pb));
  212.     osErr = MemError();
  213.     if (0 != pb && noErr == osErr) {
  214.         (*pb).ioRefNum                = ioRefNum;
  215.         (*pb).csCode                = csAStatus;
  216.         osErr = PBControl((ParmBlkPtr)pb, false);
  217.         if (noErr == osErr) {
  218.             *audioStatus        = (*pb).csParam.audioStatus;
  219.             *playMode            = (*pb).csParam.playMode;
  220.             *cntlField            = (*pb).csParam.cntlField;
  221.             *minutes            = BCD2Decimal((*pb).csParam.minutes);
  222.             *seconds            = BCD2Decimal((*pb).csParam.seconds);
  223.             *frames                = BCD2Decimal((*pb).csParam.frames);
  224.         }
  225.         DisposPtr((Ptr) pb);
  226.     }
  227.     return osErr;
  228. }
  229.  
  230. pascal OSErr DiscStatus(short ioRefNum, Boolean *discInPlace) {
  231.  
  232.     auto    OSErr            osErr;
  233.     auto    DiscStatusRec    *pb;    
  234.  
  235.     pb = (DiscStatusRec *) NewPtrClear(sizeof (*pb));
  236.     osErr = MemError();
  237.     if (0 != pb && noErr == osErr) {
  238.         (*pb).ioRefNum             = ioRefNum;
  239.         (*pb).csCode            = csDiscStatus;
  240.         osErr = PBStatus((ParmBlkPtr)pb, false);
  241.         if (noErr == osErr)
  242.             *discInPlace = (1 == (*pb).csParam.discInPlace);
  243.         DisposPtr((Ptr) pb);
  244.     }
  245.     return osErr;
  246. }
  247.  
  248. pascal    OSErr    ReadQ(short ioRefNum, Byte *cntlField, Byte *track, Byte *index, Byte *trackMinutes, Byte *trackSeconds, Byte *trackFrames, Byte *discMinutes, Byte *discSeconds, Byte *discFrames) {
  249.  
  250.     auto    OSErr            osErr;
  251.     auto    ReadQRec        *pb;
  252.     
  253.     pb = (ReadQRec *) NewPtrClear(sizeof (*pb));
  254.     osErr = MemError();
  255.     if (0 != pb && noErr == osErr) {
  256.         (*pb).ioRefNum                    = ioRefNum;
  257.         (*pb).csCode                    = csReadQ;
  258.         osErr = PBControl((ParmBlkPtr)pb, false);
  259.         if (noErr == osErr) {
  260.             *cntlField         = (*pb).csParam.cntlField;
  261.             *track             = BCD2Decimal((*pb).csParam.track);
  262.             *index             = (*pb).csParam.index;
  263.             *cntlField         = (*pb).csParam.cntlField;
  264.             *trackMinutes     = BCD2Decimal((*pb).csParam.trackMinutes);
  265.             *trackSeconds    = BCD2Decimal((*pb).csParam.trackSeconds);
  266.             *trackFrames    = BCD2Decimal((*pb).csParam.trackFrames);
  267.             *discMinutes     = BCD2Decimal((*pb).csParam.discMinutes);
  268.             *discSeconds    = BCD2Decimal((*pb).csParam.discSeconds);
  269.             *discFrames        = BCD2Decimal((*pb).csParam.discFrames);
  270.         }
  271.         DisposPtr((Ptr) pb);
  272.     }
  273.     return osErr;
  274. }
  275.  
  276. pascal    OSErr    AScan(short ioRefNum, Byte minutes, Byte seconds, Byte frames, Byte direction) {
  277.  
  278.     auto    OSErr            osErr;
  279.     auto    AScanRec        *pb;    
  280.  
  281.     pb = (AScanRec *) NewPtrClear(sizeof (*pb));
  282.     osErr = MemError();
  283.     if (0 != pb && noErr == osErr) {
  284.         (*pb).ioRefNum             = ioRefNum;
  285.         (*pb).csCode            = csAScan;
  286.         (*pb).csParam.type        = MSFADDR;
  287.         (*pb).csParam.addr[1]    = Decimal2BCD(minutes);
  288.         (*pb).csParam.addr[2]    = Decimal2BCD(seconds);
  289.         (*pb).csParam.addr[3]    = Decimal2BCD(frames);
  290.         (*pb).csParam.direction    = direction;
  291.         osErr = PBControl((ParmBlkPtr)pb, false);
  292.         DisposPtr((Ptr) pb);
  293.     }
  294.     return osErr;
  295. }
  296.